package lambdatest;

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;

/**
 * Created with IntelliJ IDEA.
 * Description: 测试 lambda 表达式
 * User:周次煜
 * Date: 2024-04-28
 * Time：21:12
 */














@FunctionalInterface
interface NoParameterNoreturn {

    void func();
}

@FunctionalInterface

interface OneParameterNoreturn {
    void  func(int x);
}



@FunctionalInterface

interface OneParameterReturn {
    int func(int x);
}


@FunctionalInterface
interface MoreParameterReturn {
    int func(int x,int y);
}

@FunctionalInterface
interface  MoreParameterNoreturn {
    void  func(int x,int y);
}

public class Test {




    // 两个参数无返回值
    private  static void  MoreParameterNoreturnTest() {
//        MoreParameterNoreturn moreParameterNoreturn=new MoreParameterNoreturn() {
//            @Override
//            public void func(int x, int y) {
//                System.out.println("你输入的两个数据的除数为: "+(x/y));
//            }
//        };


        MoreParameterNoreturn moreParameterNoreturn=(x, y) ->  System.out.println("你输入的两个数据的除数为: "+(x/y));

        moreParameterNoreturn.func(100,10);
    }


    /**
     * 两个参数有返回值的 lambda 表达式
     * () 对于这个多参数的参数列表来说 必须带上
     * return 可以省略
     */

    // 两个参数有返回值
    private  static  void  MoreParameterReturnTest()  {
//        MoreParameterReturn moreParameterReturn= new MoreParameterReturn() {
//            @Override
//            public int func(int x, int y) {
//                return x*y;
//            }
//        };

        MoreParameterReturn moreParameterReturn= (i,j)-> (i*j);

        System.out.println("你输入的两个数据之积为："+moreParameterReturn.func(19,30));
    }



    // 一个参数有返回值
    private  static  void  OneParameterReturnTest() {
//        OneParameterReturn oneParameterReturn = new OneParameterReturn() {
//            @Override
//            public int func(int x) {
//                return x;
//            }
//        };


        OneParameterReturn oneParameterReturn= m-> m;

        System.out.println("你输入的数据为："+oneParameterReturn.func(399));
    }


    // 有参数无返回值
    private  static  void  OneParameterNoreturnTest() {
//        OneParameterNoreturn oneParameterNoreturn=new OneParameterNoreturn() {
//            @Override
//            public void func(int x) {
//                System.out.println("你参入的数据大小为："+x);
//            }
//        };

        OneParameterNoreturn oneParameterNoreturn= n-> System.out.println("你参入的数据大小为："+n);
        oneParameterNoreturn.func(199);
    }


    // 无参数无返回值
   public static void NoParameterNoreturnTest() {
//       NoParameterNoreturn noParameterNoreturn= new NoParameterNoreturn() {
//           @Override
//           public void func() {
//               System.out.println("调用了无参数无返回值的函数接口！");
//           }
//       };


       /**
        * 无参数 无返回值的 lambed 表达式
        * () 花括号必须带上
        * -> 用这个来连接 参数列表 和方法定义
        * {} 当有多条语句时使用
        *  针对匿名内部类来使用 lambda 简化代码的冗长
        */
       NoParameterNoreturn noParameterNoreturn= () -> System.out.println("调用了无参数无返回值的函数接口！");
       noParameterNoreturn.func();
   }




    public static void main(String[] args) {
        // 无参数无返回值
        System.out.println("====== 无参数无返回值 ======");
        NoParameterNoreturnTest();

        // 有参数无返回值
        System.out.println("===== 有参数无返回值 =======");
        OneParameterNoreturnTest();


        // 一个参数有返回值
        System.out.println("======== 一个参数有返回值 =======");
        OneParameterReturnTest();


        //  两个参数有返回值
        System.out.println("===== 两个参数有返回值 =======");
        MoreParameterReturnTest();

        // 两个参数无返回值

        System.out.println("====== 两个参数无返回值 ========");
        MoreParameterNoreturnTest();

    }
}


class  Stu {
    String name;
    int age;

    public Stu(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class  Test1 {
    public static void main(String[] args) {
        Stu[] stus= new  Stu[] {new Stu("周白白大阿姨",29),new Stu("周伯伯",63),new Stu("周黑黑",39)};
        Comparator<Stu> comparator1= (o1,o2)->o1.name.compareTo(o2.name);
        Comparator<Stu> comparator2= (o1,o2)->o1.age-o2.age;
        Arrays.sort(stus,comparator2);
        System.out.println(Arrays.toString(stus));

        PriorityQueue<Stu> priorityQueue=new PriorityQueue<>(comparator1);
        priorityQueue.add(new Stu("周白色阿姨",29));
        priorityQueue.add(new Stu("周掰掰",63));
        priorityQueue.add(new Stu("周漆黑",39));
        System.out.println(priorityQueue);
    }
}